﻿package {
	import flash.text.*;
	import flash.display.*;
	import flash.events.*;
	import flash.ui.Keyboard;
	public class Carte extends Sprite
	{
		public const VERSION = "14.12.09";
		public var eqNord:TextField;
		public var eqEst:TextField;
		public var eqOuest:TextField;
		public var conteneur:Sprite;
		public var tasDeCarte:Array;
		public var scenePrincipale:MovieClip;
		public var pseudo:TextField;
		public var pseudoLabel:TextField;
		public var valider:Bouton;
		public var passer:Passer;
		public var accepter:Accepter;
		public var saisieDeTexte:TextField;
		public var historique:TextField;
		public var scoreEquipe1:TextField;
		public var scoreEquipe2:TextField;
		public var scoreEquipe1Label:TextField;
		public var scoreEquipe2Label:TextField;
		public var coupe:TextField;
		public var derniereCarte:CarteAJouer;
		public var tabPseudo:Array;//stockage des pseudos des joueurs
		public var nomOuest:TextField;
		public var nomNord:TextField;
		public var nomEst:TextField;
		public var nbrJoueur:int;
		public var coupeLabel:TextField;
		public var atoutLabel:TextField;
		public var atoutChamp:TextField;
		public var emplacementPli:Array;
		public var msg:TextField;
		///////////////////////////////
		//flag d'etat de la partie
		public var statusJeu:int;
		
		public var statusJoueur:String;
		public var idJoueur:String;
		public var idConnexion:String;
		public var monPseudo:String;
		var connexion:ClientSocket;
		var traitementMsg:TraitementMessage;
		
		//constructeur
		public function Carte()
		{
			nbrJoueur=0;
			tabPseudo=new Array(4);
			demarrage();
			//main();
			
			
			
		}
		public function demarrage()
		{
			pseudoLabel=new TextField();
			pseudo=new TextField();
			pseudoLabel.x=280;
			pseudoLabel.y=250;
			pseudo.x=pseudoLabel.x+pseudoLabel.width+10;
			pseudo.y=pseudoLabel.y;
			pseudo.height=20;
			pseudo.background=true;
			pseudo.type = TextFieldType.INPUT;
			valider=new Bouton();
			valider.x=pseudo.x+pseudo.width+10;
			valider.y=pseudoLabel.y;
			pseudoLabel.text="Entrer votre pseudo :";
			valider.addEventListener(MouseEvent.CLICK, main);
			valider.addEventListener(KeyboardEvent.KEY_DOWN,main);
			
			addChild(pseudoLabel);
			addChild(pseudo);
			addChild(valider);
		}
		public function main(pEvt:Event):void
		{
			try
			{
				removeChild(pseudoLabel);
				removeChild(pseudo);
				removeChild(valider);
				valider.removeEventListener( MouseEvent.CLICK, main);
				pseudo.removeEventListener( KeyboardEvent.KEY_DOWN,main);
			}catch (error:Error)
			{}
			if (pseudo.text=="")
			{
				trace("vous devez saisir un pseudo");
				demarrage();
			}
			
			
			
			/*connexion au serveur*/
			this.monPseudo=pseudo.text;
			this.initPlateau();
			
			connexion= new ClientSocket("80.69.221.66",1222);
			connexion.addEventListener(ClientSocket.PBCONNEXION,connexionImpossible);
			/*initialisation du moteur de gestion de message*/
			traitementMsg= new TraitementMessage(this);
			/*ecoute de l'evenement "un message est recu"*/
			connexion.addEventListener(ClientSocket.XMLRECU,messageRecu);
			connexion.addEventListener(ClientSocket.CONNECTE,afficheConnecte);
			connexion.addEventListener(ClientSocket.DECONNECTE,deconnexion);
			traitementMsg.addEventListener(TraitementMessage.ENVOIPRET,envoyerMsg);
			traitementMsg.addEventListener(TraitementMessage.DIALOGUERECU,afficheDialogue);
			traitementMsg.addEventListener(TraitementMessage.SCORERECU,afficheScore);
			traitementMsg.addEventListener(TraitementMessage.MAINRECU,distribuerMain);
			traitementMsg.addEventListener(TraitementMessage.STATUSRECU,majStatus);
			traitementMsg.addEventListener(TraitementMessage.ATOUTRECU,afficheAtout);
			traitementMsg.addEventListener(TraitementMessage.JOUEURRECU,ajouteJoueur);
			traitementMsg.addEventListener(TraitementMessage.COULEURRECU,majAtout);
			traitementMsg.addEventListener(TraitementMessage.PLIRECU, affichePli);
			traitementMsg.addEventListener(TraitementMessage.GAGNER,gagne);
			traitementMsg.addEventListener(TraitementMessage.RAZ,raz);
			saisieDeTexte.addEventListener(KeyboardEvent.KEY_DOWN,texteSaisie);
			this.initCarte();
			//scenePrincipale = new MovieClip;
			//addChild(scenePrincipale);

			

			//carteJ.estDistribuee();
			//carteJ.x=20;
			//carteJ.y=20;
			//trace(carteJ.couleur);
		}
		
		public function majAtout(pEvt:Event):void
		{
			//affichage de la couleur d'atout prise
			atoutChamp.text=traitementMsg.atout;
			if (traitementMsg.qui!=idJoueur)
			{
				//suppression de l'affichage de l'atout pour ceux qui n'on pas pris
				removeChild(derniereCarte);
			}
		}
		public function ajouteJoueur(pEvt:Event):void
		{
			trace("AJOUT D'UN JOUEUR");
			tabPseudo[traitementMsg.joueur[0].id]=traitementMsg.joueur[0];
			trace("---ajout joueur tabPseudo["+traitementMsg.joueur[0].id+"]");
			trace("---tabPseudo["+traitementMsg.joueur[0].id+"]="+tabPseudo[traitementMsg.joueur[0].id].id);
			nbrJoueur++;
			trace("nbrjoueur ="+nbrJoueur);
			if (nbrJoueur>3)
			//si il y a 4 joueur on tri le tableau en nous mettant en premiere place
			//puis on affiche les noms dans les textField ds le sens de jeu
			{
				
				var cpt=0
				trace("DEBUG----	tabPseudo[0]="+tabPseudo[0].id);
				while ((tabPseudo[0].id!=idJoueur)&&(cpt<8))
				{
					trace("DEBUG----	tabPseudo[0]="+tabPseudo[0]);
					trace("tabPseudo[0].id="+tabPseudo[0].id+" idJoueur="+idJoueur);
						
					tabPseudo.push(tabPseudo[0]);
					tabPseudo.shift();

					cpt++;
				}
				historique.htmlText+=tabPseudo;
				nomEst.text=tabPseudo[1].id+" "+tabPseudo[1].nom;
				nomNord.text=tabPseudo[2].id+" "+tabPseudo[2].nom;
				nomOuest.text = tabPseudo[3].id + " " + tabPseudo[3].nom;
				this.newMsg("this.idJoueur = "+this.idJoueur);
				if (this.idJoueur== "0" || this.idJoueur == "2")
				{
					this.eqOuest.text = "équipe 2";
					this.eqEst.text = "équipe 2";
					this.eqNord.text = "équipe 1";
				}
				else
				{
					this.eqOuest.text = "équipe 1";
					this.eqEst.text = "équipe 1";
					this.eqNord.text = "équipe 2";
				}
			}
			
			trace("tabPseudo"+tabPseudo);
		}
		public function affichePli(pEvt:Event):void
		{
			trace("---PHASE---	reception du pli");
			trace("traitementMsg.mainRecu.length()="+traitementMsg.mainRecu.length);
			if (traitementMsg.mainRecu.length==0)
			//si le plis est vide on efface les cartes posées
			{
				this.newMsg("[DEBUG] on efface le pli précédent");
				for (var cpt:int=0;cpt<4;cpt++)
				{
					if (emplacementPli[cpt].numChildren>0)
					{
						for (var enf:int=0;enf<emplacementPli[cpt].numChildren;enf++)
						{
							emplacementPli[cpt].removeChildAt(0);
						}
					}
				}
			}
			else
			//on traite le pli recu
			{
				for (var cpt1:int=0;cpt1<traitementMsg.mainRecu.length;cpt1++)
				{
					for (var i:int=0;i<32;i++)
					{
						//addChild(tasDeCarte[i]);
						if ((tasDeCarte[i].couleur==traitementMsg.mainRecu[cpt1].couleur) && (tasDeCarte[i].numero==traitementMsg.mainRecu[cpt1].numero))
						{
							//ajout de la carte trouvée au receptacle prevu
							trace("traitementMsg.mainRecu[cpt1].qui="+traitementMsg.mainRecu[cpt1].qui);
							var temp:int;
							temp=0;
							var str:String=traitementMsg.mainRecu[cpt1].qui.toString();
							
							//on recupere la place du joueur sur la table
							temp = getPlaceJoueur(str);
							
							trace("index="+temp);
							//trace(emplacementPli[getPlaceJoueur(traitementMsg.mainRecu[cpt1].qui)]);
							tasDeCarte[i].x = 0;
							tasDeCarte[i].y = 0;
							emplacementPli[temp].addChild(tasDeCarte[i]);
							//tasDeCarte[i].estDistribuee(this);
							tasDeCarte[i].setJouable(false);
						}
					}
				}
				//affichage du contenu du conteneur nord pour comprendre pkoi elle ne s affiche plus:
				historique.appendText("nombre de carte dans emp sud :" + emplacementPli[0].numChildren);
				historique.scrollV = historique.maxScrollV;
			}
		}
		public function getPlaceJoueur(joueurCherche:String ):int
		{
			//donne la place du joueur precisé autour de la table
			trace("on cherche la place du joueur :"+joueurCherche);
			var place:int;
			place=6;
			for (var cpt:int=0;cpt<4;cpt++)
			{
				trace("test de :"+ tabPseudo[cpt].id);
				if (tabPseudo[cpt].id==joueurCherche)
				{
					trace("trouvé a la place "+cpt);
					 place = cpt;
				}
			}
			//debug
			if (place==6)
			{
				trace("joueur non trouvé");
			}
			return place ;
		}
		public function initPlateau():void
		{
			//initialisation des champs
			
			var xScore:int=10;
			var yScore:int=5;
			var couleur:uint= 0xE7D95C;
			var largeur:int=60;
			var hauteur:int =20;

			
			scoreEquipe1Label=new TextField();
			scoreEquipe2Label=new TextField();
			
			scoreEquipe1Label.x=xScore;
			scoreEquipe1Label.y=yScore;
			scoreEquipe1Label.width=largeur;
			scoreEquipe1Label.height=hauteur;
			scoreEquipe1Label.text="Equipe 1 =>";
			scoreEquipe1Label.backgroundColor=couleur;
			scoreEquipe1Label.background=true;
			

			
			
			scoreEquipe1 = new TextField();
			scoreEquipe2=new TextField();
			
			scoreEquipe1.type = TextFieldType.DYNAMIC;
			scoreEquipe2.type = TextFieldType.DYNAMIC;
			scoreEquipe1.x=xScore+largeur;
			scoreEquipe1.y=yScore;
			scoreEquipe1.width=largeur;
			scoreEquipe1.height=hauteur;
			scoreEquipe1.text="0";
			scoreEquipe1.backgroundColor=couleur;
			scoreEquipe1.background=true;
			
			scoreEquipe2Label.x=xScore+scoreEquipe1Label.x+scoreEquipe1Label.width+scoreEquipe1.x+scoreEquipe1.width+10;
			scoreEquipe2Label.y=yScore;
			scoreEquipe2Label.width=largeur;
			scoreEquipe2Label.height=hauteur;
			scoreEquipe2Label.text="Equipe 2 =>";
			scoreEquipe2Label.backgroundColor=couleur;
			scoreEquipe2Label.background=true;
			
			scoreEquipe2.x=scoreEquipe2Label.x+largeur;
			scoreEquipe2.y=yScore;
			scoreEquipe2.width=largeur;
			scoreEquipe2.height=hauteur;
			scoreEquipe2.text="0";
			scoreEquipe2.backgroundColor=couleur;
			scoreEquipe2.background=true;
			
			//noms des joueurs
			nomOuest=new TextField();
			nomNord=new TextField();
			nomEst=new TextField();
			nomOuest.x=50;
			nomOuest.y=250;
			nomNord.x=380;
			nomNord.y=50;
			nomEst.x=700;
			nomEst.y=nomOuest.y;
			addChild(nomOuest);
			addChild(nomNord);
			addChild(nomEst);
			
			//equipe des joueurs
			eqOuest = new TextField();
			eqNord = new TextField();
			eqEst = new TextField();
			eqOuest.x = nomOuest.x;
			eqOuest.y = nomOuest.y+20;
			eqNord.x = nomNord.x;
			eqNord.y = nomNord.y+20;
			eqEst.x = nomEst.x;
			eqEst.y = nomEst.y+20;
			

			addChild(this.eqEst);
			addChild(this.eqNord);
			addChild(this.eqOuest);
			
			//Champs de dialogue
			historique= new TextField();
			historique.type=TextFieldType.DYNAMIC;
			historique.multiline=true;
			historique.mouseWheelEnabled=true;
			saisieDeTexte= new TextField();
			historique.background=true;
			historique.wordWrap = true;//retour a la ligne automatique
			//TODO trouver une alternative pur AS pour pouvoir scroller en fin de textfield
			//historique.verticalScrollPosition = historique.maxVerticalScrollPosition;
			historique.x = 10 ;
            historique.y = 500 ;
            historique.width = 600 ;
            historique.height = 80 ;
			
			saisieDeTexte.type = TextFieldType.INPUT;
			saisieDeTexte.x=historique.x;
			saisieDeTexte.y=historique.y+historique.height+2;
			saisieDeTexte.width=historique.width;
			saisieDeTexte.height=20;
			saisieDeTexte.background=true;
			
			//Champ de rappel de l'atout
			atoutLabel=new TextField;
			atoutChamp=new TextField;
			atoutLabel.y=495;
			atoutLabel.x=620;
			atoutChamp.y=atoutLabel.y+20;
			atoutChamp.x=atoutLabel.x;
			atoutLabel.text="ATOUT :";
			
			//champs d'affichage des plis
			emplacementPli = new Array(3);
			for (var cpt:int=0;cpt<4;cpt++)
			{
				emplacementPli[cpt]=new MovieClip();
				addChild(emplacementPli[cpt]);
			}
			emplacementPli[0].x= 350;	//sud 
			emplacementPli[0].y=250;
			emplacementPli[1].x= 500;	//est
			emplacementPli[1].y=200;
			emplacementPli[2].x=350;	//nord
			emplacementPli[2].y=120;
			emplacementPli[3].x=200;	//ouest
			emplacementPli[3].y=emplacementPli[1].y;
			
			//ajout a l'interface
			stage.addChild(scoreEquipe1Label);
			stage.addChild(scoreEquipe2Label);
			stage.addChild(scoreEquipe1);
			stage.addChild(scoreEquipe2);
			stage.addChild(historique);
			stage.addChild(saisieDeTexte);
			addChild(atoutLabel);
			addChild(atoutChamp);
			
			

		}
		/**************************************************
		*	Gestion connexions
		**************************************************/
		public function afficheConnecte(pEvt:Event):void
		{
			afficheStatusJeu("client v"+this.VERSION);
			afficheStatusJeu("vous êtes connecté au serveur ");
			trace(historique.htmlText);
			//pseudo.text="vince";
			
			
		}
		public function deconnexion(pEvt:Event ):void
		//deconnexion
		{
			afficheStatusJeu("vous etes deconnectés!!!");
		}
		public function connexionImpossible(pEvt:Event):void
		{
			afficheStatusJeu("Echec de la connexion au serveur!!!");
		}
		public function gagne(pEvt:Event ):void
		{
			str = "L'equipe " + this.traitementMsg.qui + " remporte la partie!";
			this.newMsg(str);
	
			msg = new TextField();
			msg.cacheAsBitmap = true;
			msg.opaqueBackground = 0xFF0000;
			msg.width = 200;
			msg.text = str;
			msg.height = 20;
			msg.x = 300;
			msg.y = 250;
			addChild(msg);
			
		}
		
		
		
		
		public function afficheScore(pEvt:Event ):void
		//affichage du score mis a jour
		{
			scoreEquipe1.text=traitementMsg.scoreRecu[0];
			scoreEquipe2.text=traitementMsg.scoreRecu[1];
		}
		public function messageRecu(pEvt:Event ):void
		{
			//analyse du message recu
			if (connexion.rxml != null && connexion.rxml != "")
			{
				traitementMsg.lecture(connexion.rxml);
			}
		}
		public function texteSaisie(pEvt:KeyboardEvent):void
		{
			if ( pEvt.keyCode == Keyboard.ENTER )
			{
				traitementMsg.envoyerTexte(saisieDeTexte.text);
				saisieDeTexte.text = "";
			}
		}
		/*******************************************************************************
		* AVANCEMENT DU JEU
		*********************************************************************************/
		public function majStatus(pEvt:Event):void
		{
			var idJoueurInt:int=parseInt(idJoueur);
			
			trace ("DEBUG -> idJoueurInt="+idJoueurInt);
			trace ("DEBUG -> idJoueurInt="+traitementMsg.msgRecu);
			trace ("DEBUG -> statusJeu="+statusJeu);
			var accepteAtout:String = idJoueur;
			var poserUneCarte:String = 10+idJoueur;
			statusJoueur="attente";
			if (statusJeu<5)
			//////////////////////
			///choix de l'atout
			//////////////////////
			{
				
				if (statusJeu==idJoueurInt)
				{
					trace("DEBUG -> Phase de choix d'atout");
					demandeAtout();
				}
				else
				{
					afficheStatusJeu("Attente de prise...");
				}
			}
			else
			{
				if (statusJeu<20)
				//////////////////////
				/// Pose de carte
				//////////////////////
				{
					if ((statusJeu-10)==idJoueurInt)
					{
						afficheStatusJeu("à vous de jouer");
						statusJoueur="monTour";
						
					}
					else
					{
						afficheStatusJeu("en attente d'une carte de "+getNom(statusJeu-10));
					}
				}
				if ((19<statusJeu)&& (statusJeu<24))
				//////////////////////
				/// phase de coupe
				//////////////////////
				{
					afficheStatusJeu("identifiant : "+idJoueur);
					trace("DEBUG -> Phase de coupe");
					if (statusJeu==(20+idJoueurInt))
					{
						
						coupeQuestion();
					}
					else
					{
						afficheStatusJeu("Attente de la coupe de "+getNom(statusJeu-20));
					}
				}
			}


				
				
			//historique.htmlText+="<b>"+traitementMsg.msgRecu+"</b><br>";
			
		}
		public function getNom(idcherche:int):String
		{
			trace(tabPseudo);
			var nom:String="inconnu";
			var cpt=0;
			while (nom=="inconnu")
			{
				if (tabPseudo[cpt].id==idcherche)
				{
					nom=tabPseudo[cpt].nom;
				}
				cpt++;
			}
			return nom;
		}
		public function afficheStatusJeu(stat:String)
		{
			historique.htmlText+=stat+"\r\n";
			historique.scrollV = historique.maxScrollV;
			
		}
		public function raz(pEvent:Event)
		{
			/**
			 * remise à zero des variables de jeu, cause : deconnexion d'un client
			 * source : serveur
			 */
			this.tabPseudo = new Array();
			nbrJoueur = 0;
			afficheStatusJeu("En attente de joueurs...");
		}
		/*************************************************************
		* Gestion de l'atout
		**************************************************************/
		
		public function afficheAtout(pEvt:Event):void
		//distribution de la main recu
		{
			trace("afficheAtout");
			var isFound:Boolean=false;
			var cpt:int=0;
			while (!isFound && cpt<32)
			{
					if ((tasDeCarte[cpt].couleur==traitementMsg.mainRecu[0].couleur) && (tasDeCarte[cpt].numero==traitementMsg.mainRecu[0].numero))
					{
						//tasDeCarte[cpt].debug_affiche();
						tasDeCarte[cpt].estRetournee(this);
						this.derniereCarte=tasDeCarte[cpt];
						isFound=true;
					}
					cpt++;
			}
			if (!isFound)
			{
				trace("EXCEPTION -> Carte introuvable "+traitementMsg.mainRecu[0].numero+" de "+traitementMsg.mainRecu[0].couleur);
			}
			
		}
		public function demandeAtout()
		{
			
			accepter=new Accepter();
			accepter.x=280;
			accepter.y=300;
			passer=new Passer();
			passer.x=accepter.x+accepter.width+10;
			passer.y=accepter.y;
			accepter.addEventListener(MouseEvent.CLICK,atoutAccepte);
			passer.addEventListener(MouseEvent.CLICK,passeTour);
			this.addChild(accepter);
			this.addChild(passer);

		}
		public function atoutAccepte(pEvt:Event):void
		{
			trace("---PHASE---	Atout accepté");
			
			accepter.removeEventListener(MouseEvent.CLICK,atoutAccepte);
			passer.removeEventListener(MouseEvent.CLICK,passeTour);
			trace("carte contient accepter?"+this.contains(accepter));
			this.removeChild(accepter);
			this.removeChild(passer);
			traitementMsg.accepteAtout(derniereCarte);
		}
		public function passeTour(pEvt:Event):void
		{
			trace("---PHASE---	Passer tour Atout");
			accepter.removeEventListener(MouseEvent.CLICK,atoutAccepte);
			passer.removeEventListener(MouseEvent.CLICK,passeTour);
			this.removeChild(accepter);
			this.removeChild(passer);
			traitementMsg.refuseAtout();
		}
		
		/******************************************************************
		* CHAT
		*******************************************************************/
		public function envoyerMsg(pEvt:Event):void
		{
			trace("envoi pret");
			historique.htmlText+=traitementMsg.msg;//DEBUG
			connexion.envoyer(traitementMsg.msg);
		}
		
		public function afficheDialogue(pEvt:Event):void
		{
			trace("afficheDialogue");
			historique.htmlText+=traitementMsg.dialogue;
			trace(historique.htmlText);
			historique.scrollV = historique.maxScrollV;
		}

		//////////////////////////////////////////
		//	DEMANDE DE COUPE
		//////////////////////////////////////////
		public function coupeQuestion():void
		{
			coupeLabel=new TextField();
			coupe=new TextField();
			coupeLabel.x=300;
			coupeLabel.y=240;
			coupe.y=coupeLabel.y;
			coupe.x=coupeLabel.x+coupeLabel.width+10;
			coupe.width=30;
			coupe.height=20;
			coupe.background=true;
			coupe.type = TextFieldType.INPUT;
			
			valider=new Bouton();
			valider.x=coupe.x+coupe.width+10;
			valider.y=coupe.y;
			coupeLabel.text="taille de la coupe :";
			valider.addEventListener(MouseEvent.CLICK,testCoupe);
			addChild(coupeLabel);
			addChild(coupe);
			addChild(valider);
			
		}
		public function testCoupe(pEvt:Event):void
		{
			if ((parseInt(coupe.text)>1)&&(parseInt(coupe.text)<30))
			{
				
					traitementMsg.envoyerCoupe(coupe.text);
					valider.removeEventListener(MouseEvent.CLICK,testCoupe);
					removeChild(coupeLabel);
					removeChild(coupe);
					removeChild(valider);
				
			}
			else
			{
				historique.htmlText+="ATTENTION : vous devez au moins avoir 2 cartes dans votre coupe!!";
			}
			
		}
		/***************************************************************************
		* initialisation des cartes
		****************************************************************************/
		public function initCarte():void
		{
			CarteAJouer.setPlateau(this);
			//instanciation des cartes(32)
			tasDeCarte= new Array();
			tasDeCarte[0] = new CarteAJouer(RoiDePique,"Roi","pique",traitementMsg,this);
			tasDeCarte[1] = new CarteAJouer(DameDePique,"Dame","pique",traitementMsg,this);
			tasDeCarte[2] = new CarteAJouer(ValetDePique,"Valet","pique",traitementMsg,this);
			tasDeCarte[3] = new CarteAJouer(DixDePique,"10","pique",traitementMsg,this);
			tasDeCarte[4] = new CarteAJouer(NeufDePique,"9","pique",traitementMsg,this);
			tasDeCarte[5] = new CarteAJouer(HuitDePique,"8","pique",traitementMsg,this);
			tasDeCarte[6] = new CarteAJouer(SeptDePique,"7","pique",traitementMsg,this);
			tasDeCarte[7] = new CarteAJouer(AsDePique,"As","pique",traitementMsg,this);
			tasDeCarte[8] = new CarteAJouer(RoiDeCoeur,"Roi","coeur",traitementMsg,this);
			tasDeCarte[9] = new CarteAJouer(DameDeCoeur,"Dame","coeur",traitementMsg,this);
			tasDeCarte[10] = new CarteAJouer(ValetDeCoeur,"Valet","coeur",traitementMsg,this);
			tasDeCarte[11] = new CarteAJouer(DixDeCoeur,"10","coeur",traitementMsg,this);
			tasDeCarte[12] = new CarteAJouer(NeufDeCoeur,"9","coeur",traitementMsg,this);
			tasDeCarte[13] = new CarteAJouer(HuitDeCoeur,"8","coeur",traitementMsg,this);
			tasDeCarte[14] = new CarteAJouer(SeptDeCoeur,"7","coeur",traitementMsg,this);
			tasDeCarte[15] = new CarteAJouer(AsDeCoeur,"As","coeur",traitementMsg,this);
			tasDeCarte[16] = new CarteAJouer(RoiDeTrefle,"Roi","trefle",traitementMsg,this);
			tasDeCarte[17] = new CarteAJouer(DameDeTrefle,"Dame","trefle",traitementMsg,this);
			tasDeCarte[18] = new CarteAJouer(ValetDeTrefle,"Valet","trefle",traitementMsg,this);
			tasDeCarte[19] = new CarteAJouer(DixDeTrefle,"10","trefle",traitementMsg,this);
			tasDeCarte[20] = new CarteAJouer(NeufDeTrefle,"9","trefle",traitementMsg,this);
			tasDeCarte[21] = new CarteAJouer(HuitDeTrefle,"8","trefle",traitementMsg,this);
			tasDeCarte[22] = new CarteAJouer(SeptDeTrefle,"7","trefle",traitementMsg,this);
			tasDeCarte[23] = new CarteAJouer(AsDeTrefle,"As","trefle",traitementMsg,this);
			tasDeCarte[24] = new CarteAJouer(RoiDeCarreau,"Roi","carreau",traitementMsg,this);
			tasDeCarte[25] = new CarteAJouer(DameDeCarreau,"Dame","carreau",traitementMsg,this);
			tasDeCarte[26] = new CarteAJouer(ValetDeCarreau,"Valet","carreau",traitementMsg,this);
			tasDeCarte[27] = new CarteAJouer(DixDeCarreau,"10","carreau",traitementMsg,this);
			tasDeCarte[28] = new CarteAJouer(NeufDeCarreau,"9","carreau",traitementMsg,this);
			tasDeCarte[29] = new CarteAJouer(HuitDeCarreau,"8","carreau",traitementMsg,this);
			tasDeCarte[30] = new CarteAJouer(SeptDeCarreau,"7","carreau",traitementMsg,this);
			tasDeCarte[31] = new CarteAJouer(AsDeCarreau,"As","carreau",traitementMsg,this);
		}
		
		
		
		public function distribuerMain(pEvt:Event):void
		///////////////////////////////////
		/// distribution de la main recu
		///////////////////////////////////
		{
			//efface les cartes deja distribuée pour eviter l'accumulation
			for (var i:int=0;i<32;i++)
			{
				try
				{
					this.removeChild(tasDeCarte[i]);
				}
				catch(e:Error) 
				{
					trace("carte non distribuée");
				}
			}
			
			trace("---PHASE---	distribution des cartes recues");
			trace("traitementMsg.mainRecu[cpt1].couleur"+traitementMsg.mainRecu[0].couleur);
			trace("traitementMsg.mainRecu.length()="+traitementMsg.mainRecu.length);
			
			for (var cpt1:int=0;cpt1<traitementMsg.mainRecu.length;cpt1++)
			{
				for (i=0;i<32;i++)
				{
					//tasDeCarte[i].debug_affiche();
					if ((tasDeCarte[i].couleur==traitementMsg.mainRecu[cpt1].couleur) && (tasDeCarte[i].numero==traitementMsg.mainRecu[cpt1].numero))
					{
						tasDeCarte[i].estDistribuee(this);
						tasDeCarte[i].setJouable(traitementMsg.mainRecu[cpt1].jouable);
					}
				}
			}
			CarteAJouer.position=300;
		}
		public function newMsg(str:String)
		{
			this.historique.appendText(str+"\n");
			this.historique.scrollV = this.historique.maxScrollV;
		}
		public function poserCarte(crt:CarteAJouer)
		{
			removeChild(crt);
			crt.x = 0;
			crt.y = 0;
			this.emplacementPli[0].addChild(crt);
		}
		
		

		
		
		
		
	}
}